# qa_web.py
import os
import uuid
from flask import Flask, request, render_template_string, jsonify, session
# 导入增强版 HistoryMemory
from history1 import HistoryMemory
import time
import random
from agent2 import EnterpriseAgentSystem  # 根据你的实际文件名调整
app = Flask(__name__)
# 设置一个密钥以启用 Flask sessions (用于存储当前会话 ID)
app.secret_key = os.environ.get("SECRET_KEY", "your_default_secret_key_change_this")

# --- 初始化 HistoryMemory ---
# 可以根据需要调整参数
history_memory = HistoryMemory(max_sessions=10, max_turns_per_session=20)

# --- 初始化 EnterpriseAgentSystem ---
# 请根据你的实际 FAISS 索引路径进行修改
FAISS_INDEX_PATH = "faiss_index"  # <--- 修改为你的实际路径
try:
    enterprise_agent = EnterpriseAgentSystem(faiss_index_path=FAISS_INDEX_PATH)
    print("✅ EnterpriseAgentSystem 初始化成功")
except Exception as e:
    print(f"❌ EnterpriseAgentSystem 初始化失败: {e}")
    enterprise_agent = None  # 如果初始化失败，后续调用需要检查


def real_agent_execute(query, context=""):
    """
    使用真实的 EnterpriseAgentSystem 执行查询，并利用上下文。
    """
    if not enterprise_agent:
        return "❌ Agent 系统未初始化，请检查日志。"

    # 1. 构造包含上下文的完整提示
    #    这里我们简单地将上下文作为前缀添加到查询中。
    #    你的 Ollama 模型 (qwen3:4b) 应该能够处理这种格式的长输入。
    full_query = f"请基于以下对话历史和文档知识回答问题。\n\n对话历史:\n{context}\n\n问题:\n{query}"

    # 2. 调用你的 Agent
    #    假设 execute_query 可以处理这种格式的查询。
    #    如果你的 Agent 内部已经处理了文档检索和 Prompt 构造，
    #    你可以直接传入 full_query。
    #    或者，如果你需要更精细的控制，可以在这里调用 DocumentStorage
    #    和 ReactAgentSystem 的方法。
    try:
        # 这里我们假设 execute_query 会处理所有逻辑
        # 如果需要区分 React 和 ZeroShot，可以根据 context 或其他逻辑决定
        # 注意：execute_query 会打印到 stdout，这里我们捕获返回值
        agent_response = enterprise_agent.execute_query(full_query, user_react=True)
        return agent_response
    except Exception as e:
        print(f"Agent 执行出错: {e}")
        return f"❌ 执行查询时发生错误: {str(e)}"
def mock_agent_execute(query, context=""):
    """模拟 Agent 执行，包含上下文"""
    time.sleep(1)  # 模拟处理延迟
    # 简单地将查询和上下文的一部分作为回复返回，以模拟上下文理解
    context_summary = context.split('\n')[-2:] if context else ["无上下文"]
    context_str = " ".join(context_summary)
    # 添加一些随机性使回复更有趣
    greetings = ["你好", "明白了", "收到"]
    responses = [
        f"{random.choice(greetings)}！关于'{query}'，结合之前的对话({context_str[:50]}...)，我认为...",
        f"根据你的问题 '{query}' 和我们之前的交流，我的看法是...",
        f"查询 '{query}' 已处理。参考上下文: {context_str[:30]}...，答案是..."
    ]
    return random.choice(responses)


# --- HTML 模板 ---
HTML_TEMPLATE = """
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>低空导航知识库</title>
    <style>
        * {
            box-sizing: border-box;
            margin: 0;
            padding: 0;
        }

        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background-color: #f0f2f5;
            height: 100vh;
            display: flex;
            flex-direction: column;
        }

        .header {
            background-color: #3498db;
            color: white;
            padding: 15px 20px;
            text-align: center;
            font-size: 1.5em;
            font-weight: bold;
            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
        }

        .container {
            display: flex;
            flex: 1;
            overflow: hidden;
        }

        /* 左侧边栏 */
        .sidebar {
            width: 260px;
            background-color: #ffffff;
            border-right: 1px solid #ddd;
            display: flex;
            flex-direction: column;
            overflow: hidden;
        }

        .session-header {
            padding: 15px;
            border-bottom: 1px solid #eee;
            display: flex;
            justify-content: space-between;
            align-items: center;
        }

        .session-title {
            font-weight: bold;
            font-size: 1.1em;
        }

        #new-session-btn {
            background-color: #2ecc71;
            color: white;
            border: none;
            padding: 8px 12px;
            border-radius: 4px;
            cursor: pointer;
            font-size: 0.9em;
        }

        #new-session-btn:hover {
            background-color: #27ae60;
        }

        .session-list {
            flex: 1;
            overflow-y: auto;
            padding: 10px 0;
        }

        .session-item {
            padding: 12px 15px;
            border-bottom: 1px solid #f0f0f0;
            cursor: pointer;
            transition: background-color 0.2s;
            display: flex;
            flex-direction: column;
        }

        .session-item:hover {
            background-color: #f5f5f5;
        }

        .session-item.active {
            background-color: #e3f2fd; /* 更明显的激活状态 */
            border-left: 3px solid #3498db;
        }

        .session-item-title {
            font-weight: 500;
            white-space: nowrap;
            overflow: hidden;
            text-overflow: ellipsis;
        }

        .session-item-time {
            font-size: 0.8em;
            color: #7f8c8d;
            margin-top: 5px;
        }

        /* 右侧主内容区 */
        .main-content {
            flex: 1;
            display: flex;
            flex-direction: column;
            overflow: hidden;
        }

        /* 对话历史区域 */
        .chat-history {
            flex: 1;
            padding: 20px;
            overflow-y: auto;
            background-color: #fafafa;
            display: flex;
            flex-direction: column;
        }

        .message {
            max-width: 80%;
            padding: 12px 16px;
            margin-bottom: 15px;
            border-radius: 18px;
            position: relative;
            word-wrap: break-word;
            animation: fadeIn 0.3s ease-in-out;
        }

        @keyframes fadeIn {
            from { opacity: 0; transform: translateY(10px); }
            to { opacity: 1; transform: translateY(0); }
        }

        .user-message {
            align-self: flex-end;
            background-color: #dcf8c6;
            border-bottom-right-radius: 5px;
        }

        .agent-message {
            align-self: flex-start;
            background-color: #ffffff;
            border: 1px solid #e0e0e0;
            border-bottom-left-radius: 5px;
        }

        .message-sender {
            font-weight: bold;
            font-size: 0.85em;
            margin-bottom: 5px;
        }

        .user-message .message-sender {
            color: #27ae60;
        }

        .agent-message .message-sender {
            color: #3498db;
        }

        .message-timestamp {
            font-size: 0.7em;
            color: #95a5a6;
            text-align: right;
            margin-top: 5px;
        }

        /* 输入区域 */
        .input-area {
            padding: 15px;
            background-color: #ffffff;
            border-top: 1px solid #ddd;
            display: flex;
        }

        #user-input {
            flex: 1;
            padding: 12px;
            border: 1px solid #ccc;
            border-radius: 20px;
            font-size: 1em;
            outline: none;
        }

        #send-btn {
            background-color: #3498db;
            color: white;
            border: none;
            padding: 10px 20px;
            margin-left: 10px;
            border-radius: 20px;
            cursor: pointer;
            font-size: 1em;
            transition: background-color 0.3s;
        }

        #send-btn:hover {
            background-color: #2980b9;
        }

        #send-btn:disabled {
            background-color: #bdc3c7;
            cursor: not-allowed;
        }

        /* 加载指示器 */
        .loading {
            align-self: flex-start;
            background-color: #ffffff;
            border: 1px solid #e0e0e0;
            border-bottom-left-radius: 5px;
            border-radius: 18px;
            padding: 12px 16px;
            margin-bottom: 15px;
            font-style: italic;
            color: #7f8c8d;
        }

        /* 响应式设计 */
        @media (max-width: 768px) {
            .container {
                flex-direction: column;
            }
            .sidebar {
                width: 100%;
                height: 30%;
                border-right: none;
                border-bottom: 1px solid #ddd;
            }
        }
    </style>
</head>
<body>
    <div class="header">低空导航知识库</div>
    <div class="container">
        <div class="sidebar">
            <div class="session-header">
                <div class="session-title">会话历史</div>
                <button id="new-session-btn">新建会话</button>
            </div>
            <div class="session-list" id="session-list">
                <!-- 会话列表将通过 JS 动态填充 -->
            </div>
        </div>
        <div class="main-content">
            <div class="chat-history" id="chat-history">
                <!-- 对话历史将通过 JS 动态填充 -->
                <div class="agent-message">
                    <div class="message-sender">助手</div>
                    <div>你好！我是低空导航知识库助手。请选择一个会话或新建一个会话开始对话。</div>
                </div>
            </div>
            <div class="input-area">
                <input type="text" id="user-input" placeholder="输入消息..." autocomplete="off">
                <button id="send-btn">发送</button>
            </div>
        </div>
    </div>

    <script>
        // 全局变量
        let currentSessionId = null;

        // DOM 元素
        const sessionListElement = document.getElementById('session-list');
        const chatHistoryElement = document.getElementById('chat-history');
        const userInputElement = document.getElementById('user-input');
        const sendButtonElement = document.getElementById('send-btn');
        const newSessionButton = document.getElementById('new-session-btn');

        // --- 辅助函数 ---

        // 格式化时间戳 (简化版)
        function formatTime(timestampStr) {
             // 假设 timestampStr 是 "YYYY-MM-DD HH:MM:SS" 格式
             const parts = timestampStr.split(' ');
             if (parts.length === 2) {
                 return parts[1]; // 只返回时间部分 HH:MM:SS
             }
             return timestampStr;
        }

        // 滚动聊天历史到底部
        function scrollToBottom() {
            chatHistoryElement.scrollTop = chatHistoryElement.scrollHeight;
        }

        // 显示加载指示器
        function showLoading() {
            const loadingElement = document.createElement('div');
            loadingElement.className = 'loading';
            loadingElement.id = 'loading-indicator';
            loadingElement.textContent = '助手正在思考...';
            chatHistoryElement.appendChild(loadingElement);
            scrollToBottom();
            sendButtonElement.disabled = true;
            userInputElement.disabled = true;
        }

        // 隐藏加载指示器
        function hideLoading() {
            const loadingElement = document.getElementById('loading-indicator');
            if (loadingElement) {
                loadingElement.remove();
            }
            sendButtonElement.disabled = false;
            userInputElement.disabled = false;
            userInputElement.focus();
        }

        // --- API 调用函数 ---

        // 获取会话列表
        async function fetchSessions() {
            try {
                const response = await fetch('/api/sessions', { method: 'GET' });
                if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
                const sessions = await response.json();
                renderSessionList(sessions);
            } catch (error) {
                console.error('获取会话列表失败:', error);
                // 可以添加用户友好的错误提示
            }
        }

        // 获取指定会话的聊天历史
        async function fetchChatHistory(sessionId) {
            if (!sessionId) {
                 chatHistoryElement.innerHTML = '<div class="agent-message"><div class="message-sender">助手</div><div>请选择一个会话或新建一个会话。</div></div>';
                 return;
            }
            try {
                const response = await fetch(`/api/history/${sessionId}`, { method: 'GET' });
                if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
                const history = await response.json();
                renderChatHistory(history);
            } catch (error) {
                console.error('获取聊天历史失败:', error);
                chatHistoryElement.innerHTML = '<div class="agent-message"><div class="message-sender">助手</div><div>加载聊天历史失败。</div></div>';
            }
        }

        // 发送用户消息
        async function sendMessage(message, sessionId) {
            if (!message || !sessionId) return;

            // 1. 立即在界面上显示用户消息
            addMessageToChat('user', message, new Date().toISOString()); // 使用客户端时间

            // 2. 显示加载指示器
            showLoading();

            // 3. 发送请求到后端
            try {
                const response = await fetch('/api/chat', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ message: message, session_id: sessionId })
                });

                if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
                const data = await response.json();

                // 4. 隐藏加载指示器
                hideLoading();

                // 5. 显示 Agent 回复
                addMessageToChat('agent', data.response, data.timestamp);

                // 6. 刷新会话列表 (因为当前会话可能有了新标题或时间更新)
                await fetchSessions();

            } catch (error) {
                console.error('发送消息失败:', error);
                hideLoading();
                // 显示错误消息
                addMessageToChat('agent', '抱歉，发送消息时出错。', new Date().toISOString());
            }
        }

        // 新建会话
        async function createNewSession() {
            try {
                const response = await fetch('/api/new_session', { method: 'POST' });
                if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
                const data = await response.json();
                const newSessionId = data.session_id;

                // 切换到新会话
                currentSessionId = newSessionId;
                await fetchSessions(); // 刷新列表以包含新会话
                await fetchChatHistory(currentSessionId); // 加载新会话的（空）历史
                // 在列表中高亮新会话
                document.querySelectorAll('.session-item').forEach(item => {
                    item.classList.remove('active');
                    if (item.dataset.sessionId === currentSessionId) {
                        item.classList.add('active');
                    }
                });

            } catch (error) {
                console.error('创建新会话失败:', error);
                alert('创建新会话失败。');
            }
        }


        // --- 渲染函数 ---

        // 渲染会话列表
        function renderSessionList(sessions) {
            sessionListElement.innerHTML = '';
            if (sessions.length === 0) {
                sessionListElement.innerHTML = '<div style="padding: 15px; color: #7f8c8d; text-align: center;">暂无会话</div>';
                return;
            }
            sessions.forEach(session => {
                const sessionElement = document.createElement('div');
                sessionElement.className = 'session-item';
                if (session.id === currentSessionId) {
                    sessionElement.classList.add('active');
                }
                sessionElement.dataset.sessionId = session.id;
                sessionElement.innerHTML = `
                    <div class="session-item-title">${session.title}</div>
                    <div class="session-item-time">${session.timestamp}</div>
                `;
                sessionElement.addEventListener('click', () => {
                    currentSessionId = session.id;
                    // 更新UI高亮
                    document.querySelectorAll('.session-item').forEach(item => {
                        item.classList.remove('active');
                    });
                    sessionElement.classList.add('active');
                    // 加载聊天历史
                    fetchChatHistory(currentSessionId);
                });
                sessionListElement.appendChild(sessionElement);
            });
        }

        // 渲染聊天历史
        function renderChatHistory(history) {
            chatHistoryElement.innerHTML = '';
            if (history.length === 0) {
                 chatHistoryElement.innerHTML = '<div class="agent-message"><div class="message-sender">助手</div><div>开始对话吧！</div></div>';
                 scrollToBottom();
                 return;
            }
            history.forEach(turn => {
                 // 显示用户消息
                 addMessageToChat('user', turn.user, turn.timestamp);
                 // 显示助手消息
                 addMessageToChat('agent', turn.agent, turn.timestamp); // 注意：实际应用中可能有单独的助手回复时间戳
            });
            scrollToBottom();
        }

        // 将单条消息添加到聊天历史
        function addMessageToChat(sender, content, timestamp) {
            const messageElement = document.createElement('div');
            messageElement.className = `message ${sender}-message`;

            // 简化时间显示
            const timeStr = formatTime(timestamp); 

            messageElement.innerHTML = `
                <div class="message-sender">${sender === 'user' ? '你' : '助手'}</div>
                <div>${content}</div>
                <div class="message-timestamp">${timeStr}</div>
            `;
            chatHistoryElement.appendChild(messageElement);
            scrollToBottom();
        }

        // --- 事件监听器 ---

        // 发送按钮点击事件
        sendButtonElement.addEventListener('click', () => {
            const message = userInputElement.value.trim();
            if (message && currentSessionId) {
                sendMessage(message, currentSessionId);
                userInputElement.value = ''; // 清空输入框
            } else if(!currentSessionId) {
                 alert('请先选择或创建一个会话。');
                 // 或者自动创建一个新会话
                 // createNewSession();
            }
        });

        // 回车发送消息 (可选)
        userInputElement.addEventListener('keypress', (e) => {
            if (e.key === 'Enter' && !e.shiftKey) { // Enter without Shift
                e.preventDefault(); // 防止换行
                sendButtonElement.click();
            }
        });

        // 新建会话按钮点击事件
        newSessionButton.addEventListener('click', createNewSession);

        // --- 初始化 ---
        // 页面加载完成后获取会话列表
        window.addEventListener('DOMContentLoaded', async () => {
            await fetchSessions();
            // 可以尝试加载 Flask Session 中存储的 currentSessionId
            // 但简单起见，我们让用户手动选择或创建
        });

    </script>
</body>
</html>
"""


# --- Flask 路由 ---

@app.route("/")
def index():
    """主页面"""
    # 可以在这里从 Flask session 中尝试获取 currentSessionId
    # session_id = session.get('current_session_id')
    # if session_id:
    #     history_memory.set_current_session(session_id)
    return render_template_string(HTML_TEMPLATE)


# --- API 路由 ---

@app.route("/api/sessions", methods=["GET"])
def api_get_sessions():
    """API: 获取会话列表"""
    sessions_list = history_memory.get_sessions_list()
    return jsonify(sessions_list)


@app.route("/api/history/<session_id>", methods=["GET"])
def api_get_history(session_id):
    """API: 获取指定会话的聊天历史"""
    history = history_memory.get_history(session_id)
    return jsonify(history)


@app.route("/api/chat", methods=["POST"])
def api_chat():
    """API: 处理聊天消息"""
    data = request.get_json()
    user_message = data.get("message")
    session_id = data.get("session_id")

    if not user_message or not session_id:
        return jsonify({"error": "缺少消息或会话ID"}), 400

    # 1. 获取上下文
    context = history_memory.get_context(session_id, last_n=3)  # 获取最近3轮上下文

    # 2. 调用你的 Agent (这里用模拟函数)
    # agent_response = enterprise_agent.execute_query(user_message, context=context)
    # agent_response = mock_agent_execute(user_message, context=context)
    agent_response = real_agent_execute(user_message, context=context)  # <-- 使用真实函数

    # 3. 将对话轮次添加到历史记录
    history_memory.add_turn(user_message, agent_response, session_id)

    # 4. 返回响应
    # 注意：实际应用中，Agent 可能会返回时间戳，这里我们用当前时间
    import datetime
    response_timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return jsonify({"response": agent_response, "timestamp": response_timestamp})


@app.route("/api/new_session", methods=["POST"])
def api_new_session():
    """API: 创建新会话"""
    new_session_id = history_memory.start_new_session()
    # 将新会话ID存入 Flask session (可选)
    # session['current_session_id'] = new_session_id
    return jsonify({"session_id": new_session_id})


# 可以添加更多 API 路由，如删除会话、清空会话等
#基础版
if __name__ == "__main__":
    # 确保在非调试模式下也能重新加载模块（如果需要）
    # debug=True 会启用重载，但注意它会重启应用，可能影响 session 状态
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 5000)), debug=False)
